40 research outputs found
A Formally Specified Type System and Operational Semantics for Higher-Order Procedural Variables
We formally specified the type system and operational semantics of LOOPw with
Ott and Isabelle/HOL proof assistant. Moreover, both the type system and the
semantics of LOOPw have been tested using Isabelle/HOL program extraction
facility for inductively defined relations. In particular, the program that
computes the Ackermann function type checks and behaves as expected. The main
difference (apart from the choice of an Ada-like concrete syntax) with LOOPw
comes from the treatment of parameter passing. Indeed, since Ott does not
currently fully support alpha-conversion, we rephrased the operational
semantics with explicit aliasing in order to implement the out parameter
passing mode
A Coq-based synthesis of Scala programs which are correct-by-construction
The present paper introduces Scala-of-Coq, a new compiler that allows a
Coq-based synthesis of Scala programs which are "correct-by-construction". A
typical workflow features a user implementing a Coq functional program, proving
this program's correctness with regards to its specification and making use of
Scala-of-Coq to synthesize a Scala program that can seamlessly be integrated
into an existing industrial Scala or Java application.Comment: 2 pages, accepted version of the paper as submitted to FTfJP 2017
(Formal Techniques for Java-like Programs), June 18-23, 2017, Barcelona ,
Spai
Deriving a Hoare-Floyd logic for non-local jumps from a formulae-as-types notion of control
We derive a Hoare-Floyd logic for non-local jumps and mutable higher-order
procedural variables from a formul{\ae}-as-types notion of control for
classical logic. The main contribution of this work is the design of an
imperative dependent type system for non-local jumps which corresponds to
classical logic but where the famous consequence rule is still derivable.Comment: The 22nd Nordic Workshop on Programming Theory, Turku : Finland
(2010
WCET of OCaml Bytecode on Microcontrollers: An Automated Method and Its Formalisation
Considering the bytecode representation of a program written in a high-level programming language enables portability of its execution as well as a factorisation of various possible analyses of this program. In this article, we present a method for computing the worst-case execution time (WCET) of an embedded bytecode program fit to run on a microcontroller. Due to the simple memory model of such a device, this automated WCET computation relies only on a control-flow analysis of the program, and can be adapted to multiple models of microcontrollers. This method evaluates the bytecode program using concrete as well as partially unknown values, in order to estimate its longest execution time. We present a software tool, based on this method, that computes the WCET of a synchronous embedded OCaml program. One key contribution of this article is a mechanically checked formalisation of the aforementioned method over an idealised bytecode language, as well as its proof of correctness
A program logic for higher-order procedural variables and non-local jumps
Relying on the formulae-as-types paradigm for classical logic, we define a
program logic for an imperative language with higher-order procedural variables
and non-local jumps. Then, we show how to derive a sound program logic for this
programming language. As a by-product, we obtain a non-dependent type system
which is more permissive than what is usually found in statically typed
imperative languages. As a generic example, we encode imperative versions of
delimited continuations operators shift and reset
2015 Workshop on Continuations: pre-proceedings
This volume contains the papers presented at WoC 2015, the 2015 Workshopon Continuations held on April 12, 2015 in London, UK
A formulae-as-types interpretation of subtractive logic
We present a formulae-as-types interpretation of Subtractive Logic (i.e. bi-intuitionistic logic). This presentation is two-fold: we first define a very natural restriction of the λµ-calculus which is closed under reduction and whose type system is a constructive restriction of the Classical Natural Deduction. Then we extend this deduction system conservatively to Subtractive Logic. From a computational standpoint, the resulting calculus provides a type system for first-class coroutines (a restricted form of first-class continuations). Keywords: Curry-Howard isomorphism, Subtractive Logic, control operators, coroutines.